home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / BaseHTTPServer.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  13.6 KB  |  299 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __version__ = '0.3'
  5. __all__ = [
  6.     'HTTPServer',
  7.     'BaseHTTPRequestHandler']
  8. import sys
  9. import time
  10. import socket
  11. import mimetools
  12. import SocketServer
  13. DEFAULT_ERROR_MESSAGE = '<head>\n<title>Error response</title>\n</head>\n<body>\n<h1>Error response</h1>\n<p>Error code %(code)d.\n<p>Message: %(message)s.\n<p>Error code explanation: %(code)s = %(explain)s.\n</body>\n'
  14.  
  15. def _quote_html(html):
  16.     return html.replace('&', '&').replace('<', '<').replace('>', '>')
  17.  
  18.  
  19. class HTTPServer(SocketServer.TCPServer):
  20.     allow_reuse_address = 1
  21.     
  22.     def server_bind(self):
  23.         SocketServer.TCPServer.server_bind(self)
  24.         (host, port) = self.socket.getsockname()[:2]
  25.         self.server_name = socket.getfqdn(host)
  26.         self.server_port = port
  27.  
  28.  
  29.  
  30. class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
  31.     sys_version = 'Python/' + sys.version.split()[0]
  32.     server_version = 'BaseHTTP/' + __version__
  33.     
  34.     def parse_request(self):
  35.         self.command = None
  36.         self.request_version = version = 'HTTP/0.9'
  37.         self.close_connection = 1
  38.         requestline = self.raw_requestline
  39.         if requestline[-2:] == '\r\n':
  40.             requestline = requestline[:-2]
  41.         elif requestline[-1:] == '\n':
  42.             requestline = requestline[:-1]
  43.         
  44.         self.requestline = requestline
  45.         words = requestline.split()
  46.         if len(words) == 3:
  47.             (command, path, version) = words
  48.             if version[:5] != 'HTTP/':
  49.                 self.send_error(400, 'Bad request version (%r)' % version)
  50.                 return False
  51.             
  52.             
  53.             try:
  54.                 base_version_number = version.split('/', 1)[1]
  55.                 version_number = base_version_number.split('.')
  56.                 if len(version_number) != 2:
  57.                     raise ValueError
  58.                 
  59.                 version_number = (int(version_number[0]), int(version_number[1]))
  60.             except (ValueError, IndexError):
  61.                 self.send_error(400, 'Bad request version (%r)' % version)
  62.                 return False
  63.  
  64.             if version_number >= (1, 1) and self.protocol_version >= 'HTTP/1.1':
  65.                 self.close_connection = 0
  66.             
  67.             if version_number >= (2, 0):
  68.                 self.send_error(505, 'Invalid HTTP Version (%s)' % base_version_number)
  69.                 return False
  70.             
  71.         elif len(words) == 2:
  72.             (command, path) = words
  73.             self.close_connection = 1
  74.             if command != 'GET':
  75.                 self.send_error(400, 'Bad HTTP/0.9 request type (%r)' % command)
  76.                 return False
  77.             
  78.         elif not words:
  79.             return False
  80.         else:
  81.             self.send_error(400, 'Bad request syntax (%r)' % requestline)
  82.             return False
  83.         self.command = command
  84.         self.path = path
  85.         self.request_version = version
  86.         self.headers = self.MessageClass(self.rfile, 0)
  87.         conntype = self.headers.get('Connection', '')
  88.         if conntype.lower() == 'close':
  89.             self.close_connection = 1
  90.         elif conntype.lower() == 'keep-alive' and self.protocol_version >= 'HTTP/1.1':
  91.             self.close_connection = 0
  92.         
  93.         return True
  94.  
  95.     
  96.     def handle_one_request(self):
  97.         self.raw_requestline = self.rfile.readline()
  98.         if not self.raw_requestline:
  99.             self.close_connection = 1
  100.             return None
  101.         
  102.         if not self.parse_request():
  103.             return None
  104.         
  105.         mname = 'do_' + self.command
  106.         if not hasattr(self, mname):
  107.             self.send_error(501, 'Unsupported method (%r)' % self.command)
  108.             return None
  109.         
  110.         method = getattr(self, mname)
  111.         method()
  112.  
  113.     
  114.     def handle(self):
  115.         self.close_connection = 1
  116.         self.handle_one_request()
  117.         while not self.close_connection:
  118.             self.handle_one_request()
  119.  
  120.     
  121.     def send_error(self, code, message = None):
  122.         
  123.         try:
  124.             (short, long) = self.responses[code]
  125.         except KeyError:
  126.             (short, long) = ('???', '???')
  127.  
  128.         if message is None:
  129.             message = short
  130.         
  131.         explain = long
  132.         self.log_error('code %d, message %s', code, message)
  133.         content = self.error_message_format % {
  134.             'code': code,
  135.             'message': _quote_html(message),
  136.             'explain': explain }
  137.         self.send_response(code, message)
  138.         self.send_header('Content-Type', 'text/html')
  139.         self.send_header('Connection', 'close')
  140.         self.end_headers()
  141.         if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
  142.             self.wfile.write(content)
  143.         
  144.  
  145.     error_message_format = DEFAULT_ERROR_MESSAGE
  146.     
  147.     def send_response(self, code, message = None):
  148.         self.log_request(code)
  149.         if message is None:
  150.             if code in self.responses:
  151.                 message = self.responses[code][0]
  152.             else:
  153.                 message = ''
  154.         
  155.         if self.request_version != 'HTTP/0.9':
  156.             self.wfile.write('%s %d %s\r\n' % (self.protocol_version, code, message))
  157.         
  158.         self.send_header('Server', self.version_string())
  159.         self.send_header('Date', self.date_time_string())
  160.  
  161.     
  162.     def send_header(self, keyword, value):
  163.         if self.request_version != 'HTTP/0.9':
  164.             self.wfile.write('%s: %s\r\n' % (keyword, value))
  165.         
  166.         if keyword.lower() == 'connection':
  167.             if value.lower() == 'close':
  168.                 self.close_connection = 1
  169.             elif value.lower() == 'keep-alive':
  170.                 self.close_connection = 0
  171.             
  172.         
  173.  
  174.     
  175.     def end_headers(self):
  176.         if self.request_version != 'HTTP/0.9':
  177.             self.wfile.write('\r\n')
  178.         
  179.  
  180.     
  181.     def log_request(self, code = '-', size = '-'):
  182.         self.log_message('"%s" %s %s', self.requestline, str(code), str(size))
  183.  
  184.     
  185.     def log_error(self, *args):
  186.         self.log_message(*args)
  187.  
  188.     
  189.     def log_message(self, format, *args):
  190.         sys.stderr.write('%s - - [%s] %s\n' % (self.address_string(), self.log_date_time_string(), format % args))
  191.  
  192.     
  193.     def version_string(self):
  194.         return self.server_version + ' ' + self.sys_version
  195.  
  196.     
  197.     def date_time_string(self, timestamp = None):
  198.         if timestamp is None:
  199.             timestamp = time.time()
  200.         
  201.         (year, month, day, hh, mm, ss, wd, y, z) = time.gmtime(timestamp)
  202.         s = '%s, %02d %3s %4d %02d:%02d:%02d GMT' % (self.weekdayname[wd], day, self.monthname[month], year, hh, mm, ss)
  203.         return s
  204.  
  205.     
  206.     def log_date_time_string(self):
  207.         now = time.time()
  208.         (year, month, day, hh, mm, ss, x, y, z) = time.localtime(now)
  209.         s = '%02d/%3s/%04d %02d:%02d:%02d' % (day, self.monthname[month], year, hh, mm, ss)
  210.         return s
  211.  
  212.     weekdayname = [
  213.         'Mon',
  214.         'Tue',
  215.         'Wed',
  216.         'Thu',
  217.         'Fri',
  218.         'Sat',
  219.         'Sun']
  220.     monthname = [
  221.         None,
  222.         'Jan',
  223.         'Feb',
  224.         'Mar',
  225.         'Apr',
  226.         'May',
  227.         'Jun',
  228.         'Jul',
  229.         'Aug',
  230.         'Sep',
  231.         'Oct',
  232.         'Nov',
  233.         'Dec']
  234.     
  235.     def address_string(self):
  236.         (host, port) = self.client_address[:2]
  237.         return socket.getfqdn(host)
  238.  
  239.     protocol_version = 'HTTP/1.0'
  240.     MessageClass = mimetools.Message
  241.     responses = {
  242.         100: ('Continue', 'Request received, please continue'),
  243.         101: ('Switching Protocols', 'Switching to new protocol; obey Upgrade header'),
  244.         200: ('OK', 'Request fulfilled, document follows'),
  245.         201: ('Created', 'Document created, URL follows'),
  246.         202: ('Accepted', 'Request accepted, processing continues off-line'),
  247.         203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
  248.         204: ('No Content', 'Request fulfilled, nothing follows'),
  249.         205: ('Reset Content', 'Clear input form for further input.'),
  250.         206: ('Partial Content', 'Partial content follows.'),
  251.         300: ('Multiple Choices', 'Object has several resources -- see URI list'),
  252.         301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
  253.         302: ('Found', 'Object moved temporarily -- see URI list'),
  254.         303: ('See Other', 'Object moved -- see Method and URL list'),
  255.         304: ('Not Modified', 'Document has not changed since given time'),
  256.         305: ('Use Proxy', 'You must use proxy specified in Location to access this resource.'),
  257.         307: ('Temporary Redirect', 'Object moved temporarily -- see URI list'),
  258.         400: ('Bad Request', 'Bad request syntax or unsupported method'),
  259.         401: ('Unauthorized', 'No permission -- see authorization schemes'),
  260.         402: ('Payment Required', 'No payment -- see charging schemes'),
  261.         403: ('Forbidden', 'Request forbidden -- authorization will not help'),
  262.         404: ('Not Found', 'Nothing matches the given URI'),
  263.         405: ('Method Not Allowed', 'Specified method is invalid for this server.'),
  264.         406: ('Not Acceptable', 'URI not available in preferred format.'),
  265.         407: ('Proxy Authentication Required', 'You must authenticate with this proxy before proceeding.'),
  266.         408: ('Request Timeout', 'Request timed out; try again later.'),
  267.         409: ('Conflict', 'Request conflict.'),
  268.         410: ('Gone', 'URI no longer exists and has been permanently removed.'),
  269.         411: ('Length Required', 'Client must specify Content-Length.'),
  270.         412: ('Precondition Failed', 'Precondition in headers is false.'),
  271.         413: ('Request Entity Too Large', 'Entity is too large.'),
  272.         414: ('Request-URI Too Long', 'URI is too long.'),
  273.         415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
  274.         416: ('Requested Range Not Satisfiable', 'Cannot satisfy request range.'),
  275.         417: ('Expectation Failed', 'Expect condition could not be satisfied.'),
  276.         500: ('Internal Server Error', 'Server got itself in trouble'),
  277.         501: ('Not Implemented', 'Server does not support this operation'),
  278.         502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
  279.         503: ('Service Unavailable', 'The server cannot process the request due to a high load'),
  280.         504: ('Gateway Timeout', 'The gateway server did not receive a timely response'),
  281.         505: ('HTTP Version Not Supported', 'Cannot fulfill request.') }
  282.  
  283.  
  284. def test(HandlerClass = BaseHTTPRequestHandler, ServerClass = HTTPServer, protocol = 'HTTP/1.0'):
  285.     if sys.argv[1:]:
  286.         port = int(sys.argv[1])
  287.     else:
  288.         port = 8000
  289.     server_address = ('', port)
  290.     HandlerClass.protocol_version = protocol
  291.     httpd = ServerClass(server_address, HandlerClass)
  292.     sa = httpd.socket.getsockname()
  293.     print 'Serving HTTP on', sa[0], 'port', sa[1], '...'
  294.     httpd.serve_forever()
  295.  
  296. if __name__ == '__main__':
  297.     test()
  298.  
  299.